
import java.util.List;

public class TrendFollowingStrategy {

    private List<Double> priceData; // List of historical price data

    public TrendFollowingStrategy(List<Double> priceData) {
        this.priceData = priceData;
    }

    public void execute() {
        int dataSize = priceData.size();
        
        // Check if there is enough data for analysis
        if (dataSize < 2) {
            System.out.println("Insufficient data for analysis");
            return;
        }
        
        // Determine the trend direction based on the latest two data points
        double currentPrice = priceData.get(dataSize - 1);
        double previousPrice = priceData.get(dataSize - 2);
        
        if (currentPrice > previousPrice) {
            // Upward trend, execute buy order
            executeBuyOrder(currentPrice);
        } else if (currentPrice < previousPrice) {
            // Downward trend, execute sell order
            executeSellOrder(currentPrice);
        } else {
            // No clear trend, do nothing
            System.out.println("No clear trend");
        }
    }

    private void executeBuyOrder(double price) {
        // Place buy order logic
        System.out.println("Executing buy order at price: " + price);
        // Additional implementation for executing the buy order
    }

    private void executeSellOrder(double price) {
        // Place sell order logic
        System.out.println("Executing sell order at price: " + price);
        // Additional implementation for executing the sell order
    }

    public static void main(String[] args) {
        // Example usage
        List<Double> priceData = List.of(10.5, 11.2, 12.0, 10.8, 13.1, 11.9, 14.3, 15.2); // Example price data
        TrendFollowingStrategy strategy = new TrendFollowingStrategy(priceData);
        strategy.execute();
    }
}


import java.util.ArrayList;
import java.util.List;

public class TrendFollowingAlgorithm {

    public static List<Integer> calculateTrend(List<Integer> data, int window) {
        List<Integer> trend = new ArrayList<>();
        for (int i = window - 1; i < data.size(); i++) {
            int sum = 0;
            for (int j = i - window + 1; j <= i; j++) {
                sum += data.get(j);
            }
            int average = sum / window;
            trend.add(average);
        }
        return trend;
    }

    public static List<Integer> generateSignals(List<Integer> data, int window) {
        List<Integer> trend = calculateTrend(data, window);
        List<Integer> signals = new ArrayList<>();
        for (int i = 0; i < data.size() - window + 1; i++) {
            if (data.get(i + window - 1) > trend.get(i)) {
                signals.add(1); // Buy signals
            } else {
                signals.add(-1); // Sell signals
            }
        }
        return signals;
    }

    public static void main(String[] args) {
        List<Integer> data = new ArrayList<>();
        data.add(100);
        data.add(105);
        data.add(110);
        data.add(115);
        data.add(120);
        data.add(115);
        data.add(110);
        data.add(105);
        data.add(100);

        int windowSize = 3; // Moving average window size
        List<Integer> signals = generateSignals(data, windowSize);

        // Print Signals
        System.out.println(signals);
    }
}


import java.util.List;

public class MomentumStrategy {

    private List<Double> priceData; // List of historical price data
    private int lookbackPeriod; // Number of periods to look back for momentum calculation

    public MomentumStrategy(List<Double> priceData, int lookbackPeriod) {
        this.priceData = priceData;
        this.lookbackPeriod = lookbackPeriod;
    }

    public void execute() {
        int dataSize = priceData.size();

        // Check if there is enough data for analysis
        if (dataSize <= lookbackPeriod) {
            System.out.println("Insufficient data for analysis");
            return;
        }

        // Calculate the momentum based on the price change over the lookback period
        double momentum = priceData.get(dataSize - 1) - priceData.get(dataSize - 1 - lookbackPeriod);

        // Determine the trading decision based on the momentum value
        if (momentum > 0) {
            // Positive momentum, execute buy order
            executeBuyOrder();
        } else if (momentum < 0) {
            // Negative momentum, execute sell order
            executeSellOrder();
        } else {
            // No momentum, do nothing
            System.out.println("No momentum");
        }
    }

    private void executeBuyOrder() {
        // Place buy order logic
        System.out.println("Executing buy order");
        // Additional implementation for executing the buy order
    }

    private void executeSellOrder() {
        // Place sell order logic
        System.out.println("Executing sell order");
        // Additional implementation for executing the sell order
    }

    public static void main(String[] args) {
        // Example usage
        List<Double> priceData = List.of(100.5, 101.2, 102.0, 104.8, 108.1, 106.9, 109.3, 110.2); // Example price data
        int lookbackPeriod = 3; // Number of periods to look back for momentum calculation
        MomentumStrategy strategy = new MomentumStrategy(priceData, lookbackPeriod);
        strategy.execute();
    }
}

$$Algorithmic\ Trade$$¶

Algorithmic trading can be implemented by following these general steps:¶

Remember!!!, algorithmic trading involves both financial and technical complexities, and it's important to educate yourself, conduct thorough research, and understand the risks involved before getting started.¶

Before we start algorithmic trading, we need to define a strategy and stick to that strategy and determine our buy and sell orders. Which strategies are generally preferred and used?¶

$$JAVA \ CODES$$¶

Please note that this is a simplified example for illustrative purposes.(So basic)¶

Finally, I will determine a different strategy and explain it with Java codes.¶